const whatsappService = require('../services/whatsappService');
const config = require('../config');
const fs = require('fs');
const path = require('path');

// 创建日志目录
const logDir = path.join(process.cwd(), 'direct_logs');
if (!fs.existsSync(logDir)) {
  fs.mkdirSync(logDir, { recursive: true });
}

// 直接记录错误到文件
function logError(message, error) {
  try {
    const timestamp = new Date().toISOString();
    const logFile = path.join(logDir, 'controller_errors.log');
    
    let errorText = `[${timestamp}] ${message}\n`;
    errorText += `Error: ${error.message || 'Unknown error'}\n`;
    if (error.stack) {
      errorText += `Stack: ${error.stack}\n`;
    }
    errorText += '='.repeat(80) + '\n';
    
    fs.appendFileSync(logFile, errorText);
    console.error(`[DIRECT LOG] ${message}`);
  } catch (e) {
    console.error('Failed to write error log:', e);
  }
}

/**
 * 获取WhatsApp连接状态
 */
exports.getStatus = async (req, res) => {
  try {
    const status = whatsappService.getConnectionStatus();
    res.json(status);
  } catch (error) {
    console.error('获取WhatsApp状态出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 获取二维码
 */
exports.getQRCode = async (req, res) => {
  try {
    const qrCode = whatsappService.getQRCode();
    
    if (!qrCode) {
      return res.status(404).json({ message: '二维码暂未生成，请稍后重试' });
    }
    
    res.json({ qrCode });
  } catch (error) {
    console.error('获取二维码出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 初始化WhatsApp连接
 */
exports.initialize = async (req, res) => {
  console.log('收到初始化WhatsApp连接请求');
  
  // 设置响应超时
  res.setTimeout(300000); // 5分钟超时
  
  // 防止多次响应
  let responded = false;
  
  try {
    // 记录请求信息
    console.log('初始化请求详情:', {
      headers: req.headers['user-agent'],
      ip: req.ip,
      userId: req.user ? req.user.id : 'unknown',
      time: new Date().toISOString()
    });
    
    // 检查当前连接状态
    const currentStatus = whatsappService.getConnectionStatus();
    console.log('当前连接状态:', currentStatus);
    
    // 如果已连接，则返回成功
    if (currentStatus.status === 'connected') {
      console.log('WhatsApp已连接，无需重新初始化');
      return res.json({
        message: 'WhatsApp已连接',
        status: currentStatus
      });
    }
    
    // 如果正在连接中，返回当前状态
    if (currentStatus.status === 'connecting') {
      console.log('WhatsApp正在连接中...');
      return res.json({
        message: 'WhatsApp正在连接中，请等待...',
        status: currentStatus
      });
    }
    
    console.log('开始初始化WhatsApp连接...');
    
    // 先返回响应，告知客户端初始化已开始
    res.json({
      message: '正在初始化WhatsApp连接，请稍后查询状态',
      status: { status: 'initializing' }
    });
    responded = true;
    
    // 异步初始化，不阻塞响应
    whatsappService.initializeWhatsApp()
      .then(result => {
        console.log('WhatsApp初始化完成:', result);
      })
      .catch(error => {
        console.error('WhatsApp初始化失败:', error);
        logError('WhatsApp后台初始化失败', error);
      });
      
  } catch (error) {
    console.error('初始化WhatsApp控制器总体错误:', error);
    logError('初始化WhatsApp控制器总体错误', error);
    
    if (!responded) {
      responded = true;
      res.status(500).json({ 
        message: '服务器内部错误',
        error: error.message
      });
    }
  }
};

/**
 * 重新连接WhatsApp
 */
exports.reconnect = async (req, res) => {
  try {
    // 先断开当前连接
    await whatsappService.disconnectWhatsApp();
    
    // 重新初始化连接
    const result = await whatsappService.initializeWhatsApp();
    
    if (result) {
      res.json({
        message: '正在重新连接WhatsApp，请等待二维码生成',
        status: whatsappService.getConnectionStatus()
      });
    } else {
      res.status(500).json({
        message: '重新连接WhatsApp失败',
        status: whatsappService.getConnectionStatus()
      });
    }
  } catch (error) {
    console.error('重新连接WhatsApp出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 断开WhatsApp连接
 */
exports.disconnect = async (req, res) => {
  try {
    const result = await whatsappService.disconnectWhatsApp();
    
    if (result.success) {
      res.json(result);
    } else {
      res.status(400).json(result);
    }
  } catch (error) {
    console.error('断开WhatsApp连接出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 获取所有联系人
 */
exports.getContacts = async (req, res) => {
  try {
    const contacts = await whatsappService.getAllContacts();
    
    // 处理联系人信息，根据用户角色过滤敏感信息
    const processedContacts = contacts.map(contact => {
      const basic = {
        id: contact.id.user,
        name: contact.name || contact.pushname || '未知',
        profilePicUrl: contact.profilePicUrl,
        isGroup: contact.isGroup,
        timestamp: new Date().toISOString()
      };
      
      // 管理员可以看到所有信息
      if (req.user.role === config.roles.ADMIN) {
        return {
          ...basic,
          phone: contact.number // 显示真实电话号码
        };
      }
      
      // 销售人员看不到真实电话号码
      return {
        ...basic,
        phone: maskPhoneNumber(contact.number) // 掩码处理电话号码
      };
    });
    
    res.json(processedContacts);
  } catch (error) {
    console.error('获取联系人出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 获取单个联系人详情
 */
exports.getContact = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!id) {
      return res.status(400).json({ message: '联系人ID是必须的' });
    }
    
    try {
      const contact = await whatsappService.getContactById(id);
      
      if (!contact) {
        return res.status(404).json({ message: '联系人不存在' });
      }
      
      // 处理联系人信息
      const processedContact = {
        id: contact.id.user,
        name: contact.name || contact.pushname || '未知',
        profilePicUrl: contact.profilePicUrl,
        isGroup: contact.isGroup
      };
      
      // 根据用户角色处理敏感信息
      if (req.user.role === config.roles.ADMIN) {
        processedContact.phone = contact.number;
      } else {
        processedContact.phone = maskPhoneNumber(contact.number);
      }
      
      res.json(processedContact);
    } catch (error) {
      console.error('获取联系人详情出错:', error);
      res.status(404).json({ message: '联系人不存在或无法访问' });
    }
  } catch (error) {
    console.error('获取联系人详情出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 获取所有聊天
 */
exports.getChats = async (req, res) => {
  try {
    const chats = await whatsappService.getAllChats();
    
    // 处理聊天信息
    const processedChats = await Promise.all(chats.map(async (chat) => {
      const contact = await chat.getContact();
      
      const basic = {
        id: chat.id.user,
        name: chat.name || contact.name || contact.pushname || '未知',
        isGroup: chat.isGroup,
        timestamp: new Date().toISOString(),
        unreadCount: chat.unreadCount
      };
      
      // 如果有最后消息，获取它
      let lastMessage = null;
      if (chat.lastMessage) {
        lastMessage = {
          message: chat.lastMessage.body,
          timestamp: new Date(chat.lastMessage.timestamp * 1000).toISOString()
        };
      }
      
      // 管理员可以看到所有信息
      if (req.user.role === config.roles.ADMIN) {
        return {
          ...basic,
          phone: contact.number, // 显示真实电话号码
          lastMessage
        };
      }
      
      // 销售人员看不到真实电话号码
      return {
        ...basic,
        phone: maskPhoneNumber(contact.number), // 掩码处理电话号码
        lastMessage
      };
    }));
    
    res.json(processedChats);
  } catch (error) {
    console.error('获取聊天出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 获取连接的设备信息
 */
exports.getDeviceInfo = async (req, res) => {
  try {
    const info = await whatsappService.getDeviceInfo();
    res.json(info);
  } catch (error) {
    console.error('获取设备信息出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 设置状态信息
 */
exports.setStatus = async (req, res) => {
  try {
    const { status } = req.body;
    
    if (!status) {
      return res.status(400).json({ message: '状态信息是必须的' });
    }
    
    const result = await whatsappService.setStatus(status);
    
    if (result.success) {
      res.json({ message: '状态已更新', status });
    } else {
      res.status(400).json({ message: '更新状态失败', error: result.error });
    }
  } catch (error) {
    console.error('设置状态信息出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 掩码电话号码辅助函数
 */
function maskPhoneNumber(phoneNumber) {
  if (!phoneNumber) return '未知';
  
  // 保留前3位和最后2位，其余用*替换
  if (phoneNumber.length > 5) {
    const prefix = phoneNumber.substring(0, 3);
    const suffix = phoneNumber.substring(phoneNumber.length - 2);
    const stars = '*'.repeat(phoneNumber.length - 5);
    return `${prefix}${stars}${suffix}`;
  }
  
  return phoneNumber; // 如果号码太短，则直接返回
}

/**
 * 获取用户专属的WhatsApp连接状态
 */
exports.getUserStatus = async (req, res) => {
  try {
    const { userId } = req.params;
    
    // 验证用户权限
    if (req.user.role !== 'admin' && req.user.id.toString() !== userId) {
      return res.status(403).json({ message: '无权访问其他用户的连接状态' });
    }
    
    const status = whatsappService.getConnectionStatus(userId);
    const sessionInfo = await getSessionInfo(userId);
    const deviceInfo = await getDeviceInfo(userId);
    
    res.json({
      ...status,
      sessionInfo,
      deviceInfo
    });
  } catch (error) {
    console.error('获取用户WhatsApp状态出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 获取用户专属的二维码
 */
exports.getUserQRCode = async (req, res) => {
  try {
    const { userId } = req.params;
    
    // 验证用户权限
    if (req.user.role !== 'admin' && req.user.id.toString() !== userId) {
      return res.status(403).json({ message: '无权访问其他用户的二维码' });
    }
    
    const qrCode = whatsappService.getQRCode(userId);
    
    if (!qrCode) {
      return res.status(404).json({ message: '二维码暂未生成，请稍后重试' });
    }
    
    res.json({ qrCode, userId });
  } catch (error) {
    console.error('获取用户二维码出错:', error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 初始化用户专属的WhatsApp连接
 */
exports.initializeUser = async (req, res) => {
  const { userId } = req.params;
  
  console.log(`收到用户 ${userId} 的初始化WhatsApp连接请求`);
  
  // 验证用户权限
  if (req.user.role !== 'admin' && req.user.id.toString() !== userId) {
    return res.status(403).json({ message: '无权初始化其他用户的连接' });
  }
  
  // 设置响应超时
  res.setTimeout(300000); // 5分钟超时
  
  // 防止多次响应
  let responded = false;
  
  try {
    // 记录请求信息
    console.log(`用户 ${userId} 初始化请求详情:`, {
      headers: req.headers['user-agent'],
      ip: req.ip,
      requestUserId: req.user.id,
      time: new Date().toISOString()
    });
    
    // 检查当前连接状态
    const currentStatus = whatsappService.getConnectionStatus(userId);
    console.log(`用户 ${userId} 当前连接状态:`, currentStatus);
    
    // 如果已连接，则返回成功
    if (currentStatus.status === 'connected') {
      console.log(`用户 ${userId} WhatsApp已连接，无需重新初始化`);
      const sessionInfo = await getSessionInfo(userId);
      return res.json({
        message: 'WhatsApp已连接',
        status: currentStatus,
        sessionInfo
      });
    }
    
    // 如果正在连接中，返回当前状态
    if (currentStatus.status === 'connecting') {
      console.log(`用户 ${userId} WhatsApp正在连接中...`);
      return res.json({
        message: 'WhatsApp正在连接中，请等待...',
        status: currentStatus
      });
    }
    
    console.log(`开始为用户 ${userId} 初始化WhatsApp连接...`);
    
    // 先返回响应，告知客户端初始化已开始
    res.json({
      message: `正在为用户 ${userId} 初始化WhatsApp连接，请稍后查询状态`,
      status: { status: 'initializing' }
    });
    responded = true;
    
    // 异步初始化，不阻塞响应
    whatsappService.initializeWhatsApp(userId)
      .then(result => {
        console.log(`用户 ${userId} WhatsApp初始化完成:`, result);
        
        // 通过WebSocket通知前端
        global.io?.to(userId).emit(`whatsapp:status:${userId}`, {
          status: result ? 'connecting' : 'error',
          message: result ? '正在生成二维码...' : '初始化失败',
          userId
        });
      })
      .catch(error => {
        console.error(`用户 ${userId} WhatsApp初始化失败:`, error);
        logError(`用户 ${userId} WhatsApp后台初始化失败`, error);
        
        // 通过WebSocket通知前端
        global.io?.to(userId).emit(`whatsapp:status:${userId}`, {
          status: 'error',
          message: '初始化失败: ' + error.message,
          userId
        });
      });
      
  } catch (error) {
    console.error(`用户 ${userId} 初始化WhatsApp控制器总体错误:`, error);
    logError(`用户 ${userId} 初始化WhatsApp控制器总体错误`, error);
    
    if (!responded) {
      responded = true;
      res.status(500).json({ 
        message: '服务器内部错误',
        error: error.message
      });
    }
  }
};

/**
 * 断开用户专属的WhatsApp连接
 */
exports.disconnectUser = async (req, res) => {
  try {
    const { userId } = req.params;
    
    // 验证用户权限
    if (req.user.role !== 'admin' && req.user.id.toString() !== userId) {
      return res.status(403).json({ message: '无权断开其他用户的连接' });
    }
    
    const result = await whatsappService.disconnectWhatsApp(userId);
    
    if (result.success) {
      // 通过WebSocket通知前端
      global.io?.to(userId).emit(`whatsapp:status:${userId}`, {
        status: 'disconnected',
        message: '连接已断开',
        userId
      });
      
      res.json(result);
    } else {
      res.status(400).json(result);
    }
  } catch (error) {
    console.error(`断开用户 ${userId} WhatsApp连接出错:`, error);
    res.status(500).json({ message: '服务器内部错误' });
  }
};

/**
 * 获取用户会话信息
 */
async function getSessionInfo(userId) {
  try {
    const db = require('../models');
    const session = await db.WhatsappSession.findOne({
      where: { 
        userId: userId,
        status: 'connected'
      },
      order: [['startTime', 'DESC']]
    });
    
    if (session) {
      return {
        sessionId: session.sessionId,
        phoneNumber: session.phoneNumber,
        startTime: session.startTime,
        duration: session.duration,
        messageCount: session.messageCount,
        contactCount: session.contactCount
      };
    }
    
    return null;
  } catch (error) {
    console.error(`获取用户 ${userId} 会话信息失败:`, error);
    return null;
  }
}

/**
 * 获取用户设备信息
 */
async function getDeviceInfo(userId) {
  try {
    const db = require('../models');
    const session = await db.WhatsappSession.findOne({
      where: { 
        userId: userId,
        status: 'connected'
      },
      order: [['startTime', 'DESC']]
    });
    
    if (session) {
      return {
        deviceType: session.loginDeviceType,
        batteryLevel: session.batteryLevel
      };
    }
    
    return null;
  } catch (error) {
    console.error(`获取用户 ${userId} 设备信息失败:`, error);
    return null;
  }
} 